package com.sourcetrip.my.modle;

import java.util.Comparator;
import java.util.Objects;

/**
 * @author: ZhouBert
 * @date: 2020/12/28
 * @description: 简单比较单元
 */
public class SimpleSortItem implements Comparable<SimpleSortItem> {


	public Integer value;

	public Integer score;

	public String name;

	public SimpleSortItem(Integer value) {
		this.value = value;
	}

	public SimpleSortItem(Integer value, Integer score) {
		this.value = value;
		this.score = score;
	}

	/**
	 * 默认比较 value
	 *
	 * @param o
	 * @return
	 */
	@Override
	public int compareTo(SimpleSortItem o) {
//		if (!(o instanceof SimpleSortItem)) {
//			throw new IllegalArgumentException("比较对象不是 SimpleSortItem!");
//		}
		//return this.value.compareTo(((SimpleSortItem) o).getValue());
		return this.value.compareTo(o.value);
	}

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		SimpleSortItem that = (SimpleSortItem) o;
		return Objects.equals(value, that.value);
	}

	@Override
	public int hashCode() {

		return Objects.hash(value);
	}

	@Override
	public String toString() {
		return value + "";
	}

	//region	static methods

	/**
	 * 返回随机 SimpleSortItem 数组
	 *
	 * @param count 数组总数
	 * @param min   下限值
	 * @param max   上限值
	 * @return
	 */
	public static SimpleSortItem[] random(int count, int min, int max) {
		if (count <= 0 || min > max) {
			return null;
		}
		SimpleSortItem[] array = new SimpleSortItem[count];
		int delta = max - min + 1;
		for (int i = 0; i < count; i++) {
			array[i] = new SimpleSortItem(min + (int) (Math.random() * delta));
		}
		return array;
	}


	/**
	 * 数组拷贝
	 *
	 * @param oldArray
	 * @return
	 */
	public static SimpleSortItem[] copy(SimpleSortItem[] oldArray) {
		SimpleSortItem[] res = new SimpleSortItem[oldArray.length];
		System.arraycopy(oldArray, 0, res, 0, oldArray.length);
		return res;
	}

	/**
	 * 判断是否有序：
	 * 只要判断相邻两个元素是否有序，一直从头到尾。
	 *
	 * @param arr
	 * @param comparator
	 * @return
	 */
	public static boolean isAscOrder(SimpleSortItem[] arr, Comparator<SimpleSortItem> comparator) {

		if (comparator == null) {
			//使用自身的 compare 进行比较
			for (int i = 1; i < arr.length; i++) {
				if (arr[i - 1].compareTo(arr[i]) > 0) {
					return false;
				}
			}
		} else {
			for (int i = 1; i < arr.length; i++) {
				if (comparator.compare(arr[i - 1], arr[i]) > 0) {
					return false;
				}
			}
		}
		return true;
	}

	/**
	 * 判断排序是否稳定
	 * 从结果上来看的话，那只能首先找出所有相等的元素
	 * //1.从排序完成的数组 newArr 中找出 相等的集合，并放入大集合；
	 * //2.遍历大集合，比较 oldArr 中是否符合
	 * 好吧，就算实现出来了效率也不高，就用一个例子来表现吧
	 * @param oldArr
	 * @param newArr     已经排序完成的数组
	 * @param comparator 比较器
	 * @return
	 */
//	public static boolean isStable(SimpleSortItem[] oldArr, SimpleSortItem[] newArr, Comparator<SimpleSortItem> comparator) {
//
//
//
//	}


	//endregion


}
